/**
 * @license
 * Copyright Google LLC All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */
import { Replacement } from 'tslint/lib';
import { TypedRule } from 'tslint/lib/rules';
import ts from 'typescript';
const FAILURE_MESSAGE = 'Missing override modifier. Members implemented as part of ' +
    'abstract classes must explicitly set the "override" modifier. ' +
    'More details: https://github.com/microsoft/TypeScript/issues/44457#issuecomment-856202843.';
/**
 * Rule which enforces that class members implementing abstract members
 * from base classes explicitly specify the `override` modifier.
 *
 * This ensures we follow the best-practice of applying `override` for abstract-implemented
 * members so that TypeScript creates diagnostics in both scenarios where either the abstract
 * class member is removed, or renamed.
 *
 * More details can be found here: https://github.com/microsoft/TypeScript/issues/44457.
 */
export class Rule extends TypedRule {
    applyWithProgram(sourceFile, program) {
        return this.applyWithFunction(sourceFile, (ctx) => visitNode(sourceFile, ctx, program));
    }
}
/**
 * For a TypeScript AST node and each of its child nodes, check whether the node is a class
 * element which implements an abstract member but does not have the `override` keyword.
 */
function visitNode(node, ctx, program) {
    // If a class element implements an abstract member but does not have the
    // `override` keyword, create a lint failure.
    if (ts.isClassElement(node) &&
        !hasOverrideModifier(node) &&
        matchesParentAbstractElement(node, program)) {
        ctx.addFailureAtNode(node, FAILURE_MESSAGE, Replacement.appendText(node.getStart(), `override `));
    }
    ts.forEachChild(node, (n) => visitNode(n, ctx, program));
}
/**
 * Checks if the specified class element matches a parent abstract class element. i.e.
 * whether the specified member "implements" an abstract member from a base class.
 */
function matchesParentAbstractElement(node, program) {
    const containingClass = node.parent;
    // If the property we check does not have a property name, we cannot look for similarly-named
    // members in parent classes and therefore return early.
    if (node.name === undefined) {
        return false;
    }
    const propertyName = getPropertyNameText(node.name);
    const typeChecker = program.getTypeChecker();
    // If the property we check does not have a statically-analyzable property name,
    // we cannot look for similarly-named members in parent classes and return early.
    if (propertyName === null) {
        return false;
    }
    return checkClassForInheritedMatchingAbstractMember(containingClass, typeChecker, propertyName);
}
/** Checks if the given class inherits an abstract member with the specified name. */
function checkClassForInheritedMatchingAbstractMember(clazz, typeChecker, searchMemberName) {
    const baseClass = getBaseClass(clazz, typeChecker);
    // If the class is not `abstract`, then all parent abstract methods would need to
    // be implemented, and there is never an abstract member within the class.
    if (baseClass === null || !hasAbstractModifier(baseClass)) {
        return false;
    }
    const matchingMember = baseClass.members.find((m) => m.name !== undefined && getPropertyNameText(m.name) === searchMemberName);
    if (matchingMember !== undefined) {
        return hasAbstractModifier(matchingMember);
    }
    return checkClassForInheritedMatchingAbstractMember(baseClass, typeChecker, searchMemberName);
}
/** Gets the base class for the given class declaration. */
function getBaseClass(node, typeChecker) {
    const baseTypes = getExtendsHeritageExpressions(node);
    if (baseTypes.length > 1) {
        throw Error('Class unexpectedly extends from multiple types.');
    }
    const baseClass = typeChecker.getTypeAtLocation(baseTypes[0]).getSymbol();
    const baseClassDecl = baseClass?.valueDeclaration ?? baseClass?.declarations?.[0];
    if (baseClassDecl !== undefined && ts.isClassDeclaration(baseClassDecl)) {
        return baseClassDecl;
    }
    return null;
}
/** Gets the `extends` base type expressions of the specified class. */
function getExtendsHeritageExpressions(classDecl) {
    if (classDecl.heritageClauses === undefined) {
        return [];
    }
    const result = [];
    for (const clause of classDecl.heritageClauses) {
        if (clause.token === ts.SyntaxKind.ExtendsKeyword) {
            result.push(...clause.types);
        }
    }
    return result;
}
/** Gets whether the specified node has the `abstract` modifier applied. */
function hasAbstractModifier(node) {
    return !!node.modifiers?.some((s) => s.kind === ts.SyntaxKind.AbstractKeyword);
}
/** Gets whether the specified node has the `override` modifier applied. */
function hasOverrideModifier(node) {
    return !!node.modifiers?.some((s) => s.kind === ts.SyntaxKind.OverrideKeyword);
}
/** Gets the property name text of the specified property name. */
function getPropertyNameText(name) {
    if (ts.isComputedPropertyName(name)) {
        return null;
    }
    return name.text;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"noImplicitOverrideAbstractRule.js","sourceRoot":"","sources":["../../../../tslint-rules/noImplicitOverrideAbstractRule.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {Replacement, RuleFailure, WalkContext} from 'tslint/lib';\nimport {TypedRule} from 'tslint/lib/rules';\nimport ts from 'typescript';\n\nconst FAILURE_MESSAGE =\n  'Missing override modifier. Members implemented as part of ' +\n  'abstract classes must explicitly set the \"override\" modifier. ' +\n  'More details: https://github.com/microsoft/TypeScript/issues/44457#issuecomment-856202843.';\n\n/**\n * Rule which enforces that class members implementing abstract members\n * from base classes explicitly specify the `override` modifier.\n *\n * This ensures we follow the best-practice of applying `override` for abstract-implemented\n * members so that TypeScript creates diagnostics in both scenarios where either the abstract\n * class member is removed, or renamed.\n *\n * More details can be found here: https://github.com/microsoft/TypeScript/issues/44457.\n */\nexport class Rule extends TypedRule {\n  override applyWithProgram(sourceFile: ts.SourceFile, program: ts.Program): RuleFailure[] {\n    return this.applyWithFunction(sourceFile, (ctx) => visitNode(sourceFile, ctx, program));\n  }\n}\n\n/**\n * For a TypeScript AST node and each of its child nodes, check whether the node is a class\n * element which implements an abstract member but does not have the `override` keyword.\n */\nfunction visitNode(node: ts.Node, ctx: WalkContext, program: ts.Program) {\n  // If a class element implements an abstract member but does not have the\n  // `override` keyword, create a lint failure.\n  if (\n    ts.isClassElement(node) &&\n    !hasOverrideModifier(node) &&\n    matchesParentAbstractElement(node, program)\n  ) {\n    ctx.addFailureAtNode(\n      node,\n      FAILURE_MESSAGE,\n      Replacement.appendText(node.getStart(), `override `),\n    );\n  }\n\n  ts.forEachChild(node, (n) => visitNode(n, ctx, program));\n}\n\n/**\n * Checks if the specified class element matches a parent abstract class element. i.e.\n * whether the specified member \"implements\" an abstract member from a base class.\n */\nfunction matchesParentAbstractElement(node: ts.ClassElement, program: ts.Program): boolean {\n  const containingClass = node.parent as ts.ClassDeclaration;\n\n  // If the property we check does not have a property name, we cannot look for similarly-named\n  // members in parent classes and therefore return early.\n  if (node.name === undefined) {\n    return false;\n  }\n\n  const propertyName = getPropertyNameText(node.name);\n  const typeChecker = program.getTypeChecker();\n\n  // If the property we check does not have a statically-analyzable property name,\n  // we cannot look for similarly-named members in parent classes and return early.\n  if (propertyName === null) {\n    return false;\n  }\n\n  return checkClassForInheritedMatchingAbstractMember(containingClass, typeChecker, propertyName);\n}\n\n/** Checks if the given class inherits an abstract member with the specified name. */\nfunction checkClassForInheritedMatchingAbstractMember(\n  clazz: ts.ClassDeclaration,\n  typeChecker: ts.TypeChecker,\n  searchMemberName: string,\n): boolean {\n  const baseClass = getBaseClass(clazz, typeChecker);\n\n  // If the class is not `abstract`, then all parent abstract methods would need to\n  // be implemented, and there is never an abstract member within the class.\n  if (baseClass === null || !hasAbstractModifier(baseClass)) {\n    return false;\n  }\n\n  const matchingMember = baseClass.members.find(\n    (m) => m.name !== undefined && getPropertyNameText(m.name) === searchMemberName,\n  );\n\n  if (matchingMember !== undefined) {\n    return hasAbstractModifier(matchingMember);\n  }\n\n  return checkClassForInheritedMatchingAbstractMember(baseClass, typeChecker, searchMemberName);\n}\n\n/** Gets the base class for the given class declaration. */\nfunction getBaseClass(\n  node: ts.ClassDeclaration,\n  typeChecker: ts.TypeChecker,\n): ts.ClassDeclaration | null {\n  const baseTypes = getExtendsHeritageExpressions(node);\n\n  if (baseTypes.length > 1) {\n    throw Error('Class unexpectedly extends from multiple types.');\n  }\n\n  const baseClass = typeChecker.getTypeAtLocation(baseTypes[0]).getSymbol();\n  const baseClassDecl = baseClass?.valueDeclaration ?? baseClass?.declarations?.[0];\n\n  if (baseClassDecl !== undefined && ts.isClassDeclaration(baseClassDecl)) {\n    return baseClassDecl;\n  }\n\n  return null;\n}\n\n/** Gets the `extends` base type expressions of the specified class. */\nfunction getExtendsHeritageExpressions(\n  classDecl: ts.ClassDeclaration,\n): ts.ExpressionWithTypeArguments[] {\n  if (classDecl.heritageClauses === undefined) {\n    return [];\n  }\n  const result: ts.ExpressionWithTypeArguments[] = [];\n  for (const clause of classDecl.heritageClauses) {\n    if (clause.token === ts.SyntaxKind.ExtendsKeyword) {\n      result.push(...clause.types);\n    }\n  }\n  return result;\n}\n\n/** Gets whether the specified node has the `abstract` modifier applied. */\nfunction hasAbstractModifier(node: ts.Node): boolean {\n  return !!node.modifiers?.some((s) => s.kind === ts.SyntaxKind.AbstractKeyword);\n}\n\n/** Gets whether the specified node has the `override` modifier applied. */\nfunction hasOverrideModifier(node: ts.Node): boolean {\n  return !!node.modifiers?.some((s) => s.kind === ts.SyntaxKind.OverrideKeyword);\n}\n\n/** Gets the property name text of the specified property name. */\nfunction getPropertyNameText(name: ts.PropertyName): string | null {\n  if (ts.isComputedPropertyName(name)) {\n    return null;\n  }\n  return name.text;\n}\n"]}